#ifndef __M_SRV_H__
#define __M_SRV_H__
#include "db.hpp"
#include "match.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "util.hpp"

#define WWWROOT "./wwwroot/"
class gobang_server
{
private:
    std::string _web_root;//静态资源根目录 ./wwwroot/
    wsserver_t _wssrv;
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    matcher _mm;
    session_manager _sm;
private:
    /*静态资源请求处理*/
    void file_handler(wsserver_t::connection_ptr& conn)
    {
        /*对于静态资源的请求，我们需要先获取HTTP请求对象，然后通过请求对象，获取HTTP请求中的uri*/
        //1.获取到请求uri--资源路径，要了解客户端的页面文件名称
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        //2.组合出文件的实际路径   相对根目录+uri
        std::string realpath = _web_root+uri;
        //3.如果在实际路径中最后的字符是/，那么表示是目录的路径，需要再加上静态资源的路径
        if(realpath.back()=='/')//目录
        {
            realpath+="login.html";//
        }
        //4.读取文件内容
        std::string body;
        bool ret = file_util::read(realpath,body);
        //如果文件不存在，则读取失败，返回404
        if(ret==false)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        
        //5.设置响应正文
        conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
    }

    void http_resp(wsserver_t::connection_ptr& conn,bool result, 
                   websocketpp::http::status_code::value code,const std::string& reason)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string resp_body;
        json_util::serialize(resp_json,resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type", "application/json");
        return;
    }

    /*用户注册请求处理*/
    void reg(wsserver_t::connection_ptr& conn)
    {
        /*从前端页面中获取数据，然后新增进数据库中，并且成功，就代表注册成功*/
        //1.获取正文内容
        //先获取请求对象，然后通过连接获取请求正文
        websocketpp::http::parser::request req = conn->get_request();
        std::string req_body = conn->get_request_body();

        //2.对正文内容进行反序列化，得到用户和密码
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body,login_info);
        if(ret==false)
        {
            DLOG("反序列化注册信息失败");
            return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请求正文格式错误");
        }
        //3.进行数据库的插入
        if(login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("⽤⼾名密码不完整");
            return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请输入用户名/密码");
        }

        ret = _ut.insert(login_info);
        if(ret==false)
        {
            DLOG("向数据库插⼊数据失败");
            return http_resp(conn,false,websocketpp::http::status_code::bad_request,"用户名已经被占用");
            
        }
        return http_resp(conn,true,websocketpp::http::status_code::ok,"注册成功");

    }

    /*用户登录请求处理*/
    void login(wsserver_t::connection_ptr& conn)
    {
        //1.获取正文信息，并进行反序列化，得到用户账号和密码
        std::string resp_body = conn->get_request_body();
        Json::Value login_info;
        bool ret = json_util::unserialize(resp_body,login_info);
        if(ret==false)
        {
            DLOG("反序列化登录信息失败");
            return http_resp(conn,false,websocketpp::http::status_code::bad_request,"反序列化登录信息失败");
        }
        //2.对账户和密码进行校验，并且将该用户的信息全部填充到login_info中
        ret = _ut.login(login_info);
        if(ret==false)
        {
            DLOG("用户名或密码错误");
            return http_resp(conn,false,websocketpp::http::status_code::bad_request,"用户名或密码错误");
        }
        //3.登录成功后，为用户创建session
        uint64_t uid = login_info["id"].asUInt64();
        session_ptr ssp = _sm.create_session(uid,LOGIN);
        if(ssp.get()==nullptr)
        {
            DLOG("创建会话失败");
            return http_resp(conn,false,websocketpp::http::status_code::bad_request,"创建会话失败");
        }
        //4.session创建成功后，设置响应头部：Set-Cookie,将session通过cookie返回
        /*将在HTTP响应中，将其中的cookie信息填入：SSID=...*/
        std::string cooike_ssid = "SSID="+std::to_string(ssp->ssid());
        /*填入cookie信息*/
        conn->append_header("Set-Cookie",cooike_ssid);
        //登录完成，将信息响应回给客户端
        return http_resp(conn,true,websocketpp::http::status_code::ok,"登录成功");
    }
    bool get_cookie_val(const std::string& cookie_str,const std::string& key,std::string& val)
    {
        std::string sep="; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str, sep, cookie_arr);
        for(auto str:cookie_arr)
        {
            std::vector<std::string> tmp_arr;
            string_util::split(str,"=",tmp_arr);
            if(tmp_arr.size()!=2){continue;}
            if(tmp_arr[0]==key)
            {
                val = tmp_arr[1];
                return true;
            }
        }
        return false;
    }
    /*用户信息获取功能请求处理*/
    void info(wsserver_t::connection_ptr& conn)
    {
        //⽤⼾信息获取功能请求的处理
        Json::Value err_resp;
        // 1. 获取请求信息中的Cookie，从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty()) 
        {
            //如果没有cookie，返回错误：没有cookie信息，让客⼾端重新登录
            return http_resp(conn, true,
            websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录");
        }
        // 1.5. 从cookie中取出ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false) 
        {
            //cookie中没有ssid，返回错误：没有ssid信息，让客⼾端重新登录
            return http_resp(conn, true,
            websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登录");
        }
        // 2. 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr) 
        {
            //没有找到session，则认为登录已经过期，需要重新登录
            return http_resp(conn, true,
            websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
        }
        // 3. 从数据库中取出⽤⼾信息，进⾏序列化发送给客⼾端
        uint64_t uid = ssp->get_user();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if (ret == false)
        {
            //获取⽤⼾信息失败，返回错误：找不到⽤⼾信息
            return http_resp(conn, true,
            websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
        }
        std::string body;
        json_util::serialize(user_info, body);
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        // 4. 刷新session的过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    void http_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string method = req.get_method();
        std::string uri = req.get_uri();
        if (method == "POST" && uri == "/reg") 
        {
            return reg(conn);
        }
        else if (method == "POST" && uri == "/login") 
        {
            return login(conn);
        }
        else if (method == "GET" && uri == "/info") 
        {
            return info(conn);
        }
        else 
        {
            return file_handler(conn);
        }
    }

    void ws_resp(wsserver_t::connection_ptr conn,Json::Value& resp)
    {
        std::string body;
        json_util::serialize(resp,body);
        conn->send(body);
    }

    //找到session对话信息
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
    {
        /*通过通信连接，获取websocket请求中的cookie，然后从cookie中获取ssid，
        取出ssid后，通过ssid最终获取session对话信息*/
        Json::Value err_resp;
        //1.获取请求信息中的Cookie，从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if(cookie_str.empty())
        {
            err_resp["optype"]="hall_ready";
            err_resp["reason"] = "没有找到cookie信息，需要重新登录";
            err_resp["result"]=false;
            //把错误信息响应回去
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        //1.1 获取cookie信息成功后，取出ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str,"SSID",ssid_str);
        if(ret==false)
        {
            err_resp["optype"]="hall_ready";
            err_resp["reason"] = "没有找到SSID信息，需要重新登录";
            err_resp["result"]=false;
            //把错误信息响应回去
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        //2. 通过ssid在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if(ssp.get()==nullptr)
        {
            err_resp["optype"]="hall_ready";
            err_resp["reason"] = "没有找到session信息，需要重新登录";
            err_resp["result"]=false;
            //把错误信息响应回去
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        return ssp;
    }
    void wsopen_game_hall(wsserver_t::connection_ptr conn)
    {
        //游戏大厅长连接建立成功
        Json::Value resp_json;
        //1.登录验证--判断当前客户端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.判断当前客户端是否异地登陆
        if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user())) 
        {
            resp_json["optype"] = "hall_ready";
            resp_json["reason"] = "玩家重复登录！";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        //3. 将当前客⼾端以及连接加⼊到游戏⼤厅
        _om.enter_game_hall(ssp->get_user(), conn);
        //4. 给客⼾端响应游戏⼤厅连接建⽴成功
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = true;
        ws_resp(conn, resp_json);
        //5. 记得将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }

    void wsopen_game_room(wsserver_t::connection_ptr conn)
    {
        //游戏房间长连接建立成功
        Json::Value resp_json;
        //1.获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.判断当前用户是否已经在在线用户管理的游戏房间或游戏大厅中--如果在，不能异地登陆/重复登录
        if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "玩家重复登录";
            resp_json["result"] = false;
            return ws_resp(conn,resp_json);
        }
        //3.判断当前用户已经是否创建好了房间--房间管理
        //根据用户id，获取所在的房间的信息
        room_ptr rp= _rm.get_room_by_uid(ssp->get_user());
        if(rp.get()==nullptr)
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "没有找到玩家房间的信息";
            resp_json["result"] = false;
            return ws_resp(conn,resp_json);
        }
        //4.将当前用户添加到在线用户管理的房间当中
        _om.enter_game_room(ssp->get_user(),conn);
        //5.将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        //6.将房间准备响应回去
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->get_rid();
        resp_json["uid"] = (Json::UInt64)ssp->get_user();
        resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
        resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
        return ws_resp(conn,resp_json);
    }
    /*游戏大厅长连接断开处理*/
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        //从uri中获取资源路径，从而得知是游戏房间的请求还是游戏大厅的请求
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if(uri=="/hall")
        {
            //获取的是游戏大厅的长连接
            return wsopen_game_hall(conn);
        }
        else if(uri=="/room")
        {
            //获取的是游戏房间的长连接
            return wsopen_game_room(conn);
        }

    }
    
    //游戏大厅关闭长连接
    void wsclose_game_hall(wsserver_t::connection_ptr conn)
    {
        //游戏⼤厅⻓连接断开的处理
        //1. 登录验证--判断当前客⼾端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.将玩家从大厅中移除
        _om.exit_game_hall(ssp->get_user());
        //2.将session恢复声明周期管理，设置定时删除
        _sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
    }

    //游戏房间关闭长连接
    void wsclose_game_room(wsserver_t::connection_ptr conn)
    {
        //获取会话信息，识别客⼾端
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        //3.将session恢复声明周期管理，设置定时删除
        _sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
        //4.将玩家从房间移除
        _rm.remove_room_user(ssp->get_user());

    }
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        //从uri中获取资源路径，从而得知是游戏房间的请求还是游戏大厅的请求
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if(uri=="/hall")
        {
            //获取的是游戏大厅的长连接
            return wsclose_game_hall(conn);
        }
        else if(uri=="/room")
        {
            //获取的是游戏房间的长连接
            return wsclose_game_room(conn);
        }
    }

    //在游戏大厅中开始进行匹配对战
    void wsmsg_game_hall(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        std::string resp_body;
        //1.身份验证，看看当前客户端是哪个玩家
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.获取请求信息
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        bool ret = json_util::unserialize(req_body,req_json);
        if(ret==false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            return ws_resp(conn,resp_json);
        }
        //3.对于请求进行处理
        if (!req_json["optype"].isNull() && req_json["optype"].asString()== "match_start")
        {
            //开始匹配对战：通过匹配模块，将玩家添加到对应的匹配队列当中
            _mm.add(ssp->get_user());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return ws_resp(conn,resp_json);
        }
        else if(!req_json["optype"].isNull() && req_json["optype"].asString()== "match_stop")
        {
            // 停⽌对战匹配：通过匹配模块，将⽤⼾从匹配队列中移除
            _mm.del(ssp->get_user());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return ws_resp(conn,resp_json);
        }
        resp_json["optype"] = "unknow";
        resp_json["reason"] = "请求类型未知";
        resp_json["result"] = false;
        return ws_resp(conn, resp_json);
    }

    //进入房间进行下棋对战或聊天
    void wsmsg_game_room(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        //1.获取session，识别客户端身份
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            DLOG("房间-没有找到会话信息");
            return;
        }
        //2.获取客⼾端房间信息
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if(rp.get()==nullptr)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            DLOG("房间-没有找到玩家房间信息");
            return ws_resp(conn, resp_json);
        }
        //3.对消息进行反序列化
        Json::Value req_json;
        std::string req_body = msg->get_payload();
        bool ret = json_util::unserialize(req_body,req_json);
        if(ret==false)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求信息解析失败";
            resp_json["result"] = false;
            DLOG("房间-请求信息解析失败");
            return ws_resp(conn, resp_json);
        }
        DLOG("房间：收到房间请求，开始处理....");
        //4. 通过房间模块进⾏消息请求的处理
        return rp->handle_request(req_json);
    }
    void wsmsg_callback(websocketpp::connection_hdl hdl,wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall") 
        {
            //建⽴了游戏⼤厅的⻓连接
            return wsmsg_game_hall(conn, msg);
        }
        else if (uri == "/room") 
        {
            //建⽴了游戏房间的⻓连接
            return wsmsg_game_room(conn, msg);
        }
    }
public:
    /*成员初始化，以及服务器回调函数的设置*/
    gobang_server(const std::string &host,
            const std::string &user,
            const std::string &pass,
            const std::string &dbname,
            uint16_t port = 3306,
            const std::string &wwwroot = WWWROOT):
            _web_root(wwwroot), _ut(host, user, pass, dbname, port),
            _rm(&_ut, &_om), _sm(&_wssrv), _mm(&_rm, &_ut, &_om)
    {
        //1.设置日志等级
        _wssrv.set_access_channels(websocketpp::log::alevel::none);/*禁止日志等级，不打印*/
        //2.初始化asio调度器
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true);
        //3.设置回调函数
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback,this,std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback,this,std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback,this,std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback,this,std::placeholders::_1,std::placeholders::_2));
    }
    /*启动服务器*/
    void start(int port)
    {
        //1.设置监听端口
        _wssrv.listen(8888);
        //2.开始获取新连接
        _wssrv.start_accept();
        //3.启动服务器
        _wssrv.run();
    }
};

#endif